/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Solutions component.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
**     of its contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef QTEDITORFACTORY_H
#define QTEDITORFACTORY_H

#include "qtpropertymanager.h"

#if QT_VERSION >= 0x040400
QT_BEGIN_NAMESPACE
#endif

class QtSpinBoxFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtSpinBoxFactory
    : public QtAbstractEditorFactory<QtIntPropertyManager> {
  Q_OBJECT
public:
  QtSpinBoxFactory(QObject *parent = 0);
  ~QtSpinBoxFactory();

protected:
  void connectPropertyManager(QtIntPropertyManager *manager);
  QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtIntPropertyManager *manager);

private:
  QtSpinBoxFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtSpinBoxFactory)
  Q_DISABLE_COPY(QtSpinBoxFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
  Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtSliderFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtSliderFactory
    : public QtAbstractEditorFactory<QtIntPropertyManager> {
  Q_OBJECT
public:
  QtSliderFactory(QObject *parent = 0);
  ~QtSliderFactory();

protected:
  void connectPropertyManager(QtIntPropertyManager *manager);
  QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtIntPropertyManager *manager);

private:
  QtSliderFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtSliderFactory)
  Q_DISABLE_COPY(QtSliderFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
  Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtScrollBarFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtScrollBarFactory
    : public QtAbstractEditorFactory<QtIntPropertyManager> {
  Q_OBJECT
public:
  QtScrollBarFactory(QObject *parent = 0);
  ~QtScrollBarFactory();

protected:
  void connectPropertyManager(QtIntPropertyManager *manager);
  QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtIntPropertyManager *manager);

private:
  QtScrollBarFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtScrollBarFactory)
  Q_DISABLE_COPY(QtScrollBarFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))
  Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtCheckBoxFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtCheckBoxFactory
    : public QtAbstractEditorFactory<QtBoolPropertyManager> {
  Q_OBJECT
public:
  QtCheckBoxFactory(QObject *parent = 0);
  ~QtCheckBoxFactory();

protected:
  void connectPropertyManager(QtBoolPropertyManager *manager);
  QWidget *createEditor(QtBoolPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtBoolPropertyManager *manager);

private:
  QtCheckBoxFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtCheckBoxFactory)
  Q_DISABLE_COPY(QtCheckBoxFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, bool))
  Q_PRIVATE_SLOT(d_func(), void slotTextVisibleChanged(QtProperty *, bool))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(bool))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtDoubleSpinBoxFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtDoubleSpinBoxFactory
    : public QtAbstractEditorFactory<QtDoublePropertyManager> {
  Q_OBJECT
public:
  QtDoubleSpinBoxFactory(QObject *parent = 0);
  ~QtDoubleSpinBoxFactory();

protected:
  void connectPropertyManager(QtDoublePropertyManager *manager);
  QWidget *createEditor(QtDoublePropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtDoublePropertyManager *manager);

private:
  QtDoubleSpinBoxFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtDoubleSpinBoxFactory)
  Q_DISABLE_COPY(QtDoubleSpinBoxFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, double))
  Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, double, double))
  Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, double))
  Q_PRIVATE_SLOT(d_func(), void slotDecimalsChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(double))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtLineEditFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtLineEditFactory
    : public QtAbstractEditorFactory<QtStringPropertyManager> {
  Q_OBJECT
public:
  QtLineEditFactory(QObject *parent = 0);
  ~QtLineEditFactory();

protected:
  void connectPropertyManager(QtStringPropertyManager *manager);
  QWidget *createEditor(QtStringPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtStringPropertyManager *manager);

private:
  QtLineEditFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtLineEditFactory)
  Q_DISABLE_COPY(QtLineEditFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QString &))
  Q_PRIVATE_SLOT(d_func(),
                 void slotRegExpChanged(QtProperty *, const QRegExp &))
  Q_PRIVATE_SLOT(d_func(), void slotEchoModeChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotReadOnlyChanged(QtProperty *, bool))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QString &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtDateEditFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtDateEditFactory
    : public QtAbstractEditorFactory<QtDatePropertyManager> {
  Q_OBJECT
public:
  QtDateEditFactory(QObject *parent = 0);
  ~QtDateEditFactory();

protected:
  void connectPropertyManager(QtDatePropertyManager *manager);
  QWidget *createEditor(QtDatePropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtDatePropertyManager *manager);

private:
  QtDateEditFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtDateEditFactory)
  Q_DISABLE_COPY(QtDateEditFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QDate &))
  Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, const QDate &,
                                                 const QDate &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDate &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtTimeEditFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtTimeEditFactory
    : public QtAbstractEditorFactory<QtTimePropertyManager> {
  Q_OBJECT
public:
  QtTimeEditFactory(QObject *parent = 0);
  ~QtTimeEditFactory();

protected:
  void connectPropertyManager(QtTimePropertyManager *manager);
  QWidget *createEditor(QtTimePropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtTimePropertyManager *manager);

private:
  QtTimeEditFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtTimeEditFactory)
  Q_DISABLE_COPY(QtTimeEditFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QTime &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QTime &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtDateTimeEditFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtDateTimeEditFactory
    : public QtAbstractEditorFactory<QtDateTimePropertyManager> {
  Q_OBJECT
public:
  QtDateTimeEditFactory(QObject *parent = 0);
  ~QtDateTimeEditFactory();

protected:
  void connectPropertyManager(QtDateTimePropertyManager *manager);
  QWidget *createEditor(QtDateTimePropertyManager *manager,
                        QtProperty *property, QWidget *parent);
  void disconnectPropertyManager(QtDateTimePropertyManager *manager);

private:
  QtDateTimeEditFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtDateTimeEditFactory)
  Q_DISABLE_COPY(QtDateTimeEditFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QDateTime &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDateTime &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtKeySequenceEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtKeySequenceEditorFactory
    : public QtAbstractEditorFactory<QtKeySequencePropertyManager> {
  Q_OBJECT
public:
  QtKeySequenceEditorFactory(QObject *parent = 0);
  ~QtKeySequenceEditorFactory();

protected:
  void connectPropertyManager(QtKeySequencePropertyManager *manager);
  QWidget *createEditor(QtKeySequencePropertyManager *manager,
                        QtProperty *property, QWidget *parent);
  void disconnectPropertyManager(QtKeySequencePropertyManager *manager);

private:
  QtKeySequenceEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtKeySequenceEditorFactory)
  Q_DISABLE_COPY(QtKeySequenceEditorFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QKeySequence &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QKeySequence &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtCharEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtCharEditorFactory
    : public QtAbstractEditorFactory<QtCharPropertyManager> {
  Q_OBJECT
public:
  QtCharEditorFactory(QObject *parent = 0);
  ~QtCharEditorFactory();

protected:
  void connectPropertyManager(QtCharPropertyManager *manager);
  QWidget *createEditor(QtCharPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtCharPropertyManager *manager);

private:
  QtCharEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtCharEditorFactory)
  Q_DISABLE_COPY(QtCharEditorFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QChar &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QChar &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtEnumEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtEnumEditorFactory
    : public QtAbstractEditorFactory<QtEnumPropertyManager> {
  Q_OBJECT
public:
  QtEnumEditorFactory(QObject *parent = 0);
  ~QtEnumEditorFactory();

protected:
  void connectPropertyManager(QtEnumPropertyManager *manager);
  QWidget *createEditor(QtEnumPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtEnumPropertyManager *manager);

private:
  QtEnumEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtEnumEditorFactory)
  Q_DISABLE_COPY(QtEnumEditorFactory)
  Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(),
                 void slotEnumNamesChanged(QtProperty *, const QStringList &))
  Q_PRIVATE_SLOT(d_func(), void slotEnumIconsChanged(QtProperty *,
                                                     const QMap<int, QIcon> &))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtCursorEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtCursorEditorFactory
    : public QtAbstractEditorFactory<QtCursorPropertyManager> {
  Q_OBJECT
public:
  QtCursorEditorFactory(QObject *parent = 0);
  ~QtCursorEditorFactory();

protected:
  void connectPropertyManager(QtCursorPropertyManager *manager);
  QWidget *createEditor(QtCursorPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtCursorPropertyManager *manager);

private:
  QtCursorEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtCursorEditorFactory)
  Q_DISABLE_COPY(QtCursorEditorFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QCursor &))
  Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
};

class QtColorEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtColorEditorFactory
    : public QtAbstractEditorFactory<QtColorPropertyManager> {
  Q_OBJECT
public:
  QtColorEditorFactory(QObject *parent = 0);
  ~QtColorEditorFactory();

protected:
  void connectPropertyManager(QtColorPropertyManager *manager);
  QWidget *createEditor(QtColorPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtColorPropertyManager *manager);

private:
  QtColorEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtColorEditorFactory)
  Q_DISABLE_COPY(QtColorEditorFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QColor &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QColor &))
};

class QtFontEditorFactoryPrivate;

class QT_QTPROPERTYBROWSER_EXPORT QtFontEditorFactory
    : public QtAbstractEditorFactory<QtFontPropertyManager> {
  Q_OBJECT
public:
  QtFontEditorFactory(QObject *parent = 0);
  ~QtFontEditorFactory();

protected:
  void connectPropertyManager(QtFontPropertyManager *manager);
  QWidget *createEditor(QtFontPropertyManager *manager, QtProperty *property,
                        QWidget *parent);
  void disconnectPropertyManager(QtFontPropertyManager *manager);

private:
  QtFontEditorFactoryPrivate *d_ptr;
  Q_DECLARE_PRIVATE(QtFontEditorFactory)
  Q_DISABLE_COPY(QtFontEditorFactory)
  Q_PRIVATE_SLOT(d_func(),
                 void slotPropertyChanged(QtProperty *, const QFont &))
  Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))
  Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QFont &))
};

class QtFilePathEditor;

class QT_QTPROPERTYBROWSER_EXPORT QtFilePathEditorFactory
    : public QtAbstractEditorFactory<QtFilePathPropertyManager> {
  Q_OBJECT
public:
  QtFilePathEditorFactory(QObject *parent = 0)
      : QtAbstractEditorFactory<QtFilePathPropertyManager>(parent) {}
  virtual ~QtFilePathEditorFactory();

protected:
  virtual void connectPropertyManager(QtFilePathPropertyManager *manager);
  virtual QWidget *createEditor(QtFilePathPropertyManager *manager,
                                QtProperty *property, QWidget *parent);
  virtual void disconnectPropertyManager(QtFilePathPropertyManager *manager);
private slots:
  void slotPropertyChanged(QtProperty *property, const QString &value);
  void slotFilterChanged(QtProperty *property, const QString &filter);
  void slotModeChanged(QtProperty *property, const QString &mode);
  void slotSetValue(const QString &value);
  void slotEditorDestroyed(QObject *object);

private:
  QMap<QtProperty *, QList<QtFilePathEditor *>> theCreatedEditors;
  QMap<QtFilePathEditor *, QtProperty *> theEditorToProperty;
};

class QPushButton;

class QT_QTPROPERTYBROWSER_EXPORT QtPushButtonFactory
    : public QtAbstractEditorFactory<QtPushButtonPropertyManager> {
  Q_OBJECT
public:
  QtPushButtonFactory(QObject *parent = 0)
      : QtAbstractEditorFactory<QtPushButtonPropertyManager>(parent) {}
  virtual ~QtPushButtonFactory();

protected:
  virtual void connectPropertyManager(QtPushButtonPropertyManager *manager);
  virtual QWidget *createEditor(QtPushButtonPropertyManager *manager,
                                QtProperty *property, QWidget *parent);
  virtual void disconnectPropertyManager(QtPushButtonPropertyManager *manager);
private slots:
  void slotPropertyChanged(QtProperty *property, const int &value);
  void slotLabelChanged(QtProperty *property, const QString &label);
  void slotButtonReleased();
  void slotEditorDestroyed(QObject *object);

private:
  QMap<QtProperty *, QList<QPushButton *>> theCreatedEditors;
  QMap<QPushButton *, QtProperty *> theEditorToProperty;
};

#if QT_VERSION >= 0x040400
QT_END_NAMESPACE
#endif

#endif
